/**
 * BarrierObstacle - 栅栏障碍物
 * 静态障碍物，玩家需要跳跃或滑铲来避开
 */

import { Obstacle, ObstacleType, ObstacleOptions } from '../Obstacle'
// import type { Sprite } from '../Entity'

/**
 * 栅栏类型枚举
 */
export enum BarrierVariant {
  LOW = 'low',      // 低栅栏 - 可以滑铲通过
  HIGH = 'high',    // 高栅栏 - 需要跳跃通过
  DOUBLE = 'double' // 双重栅栏 - 需要精确时机
}

/**
 * 栅栏障碍物配置选项
 */
export interface BarrierObstacleOptions extends Omit<ObstacleOptions, 'obstacleType' | 'height'> {
  variant?: BarrierVariant
  height?: number
}

/**
 * 栅栏障碍物类
 * @class
 * @example
 * const barrier = new BarrierObstacle({
 *   x: 400,
 *   y: 300,
 *   width: 20,
 *   height: 60,
 *   variant: BarrierVariant.HIGH
 * });
 */
export class BarrierObstacle extends Obstacle {
  public readonly variant: BarrierVariant
  private animationTime: number = 0

  /**
   * 创建栅栏障碍物
   * @param options - 栅栏配置选项
   */
  constructor(options: BarrierObstacleOptions) {
    const variant = options.variant || BarrierVariant.HIGH
    const height = options.height || BarrierObstacle.getDefaultHeight(variant)

    super({
      ...options,
      obstacleType: ObstacleType.BARRIER,
      height,
      damage: BarrierObstacle.getDamageByVariant(variant),
      scoreValue: BarrierObstacle.getScoreByVariant(variant)
    })

    this.variant = variant
  }

  /**
   * 根据变体获取默认高度
   * @param variant - 栅栏变体
   * @returns 默认高度
   */
  private static getDefaultHeight(variant: BarrierVariant): number {
    switch (variant) {
      case BarrierVariant.LOW:
        return 30
      case BarrierVariant.HIGH:
        return 60
      case BarrierVariant.DOUBLE:
        return 80
      default:
        return 60
    }
  }

  /**
   * 根据变体获取伤害值
   * @param variant - 栅栏变体
   * @returns 伤害值
   */
  private static getDamageByVariant(variant: BarrierVariant): number {
    switch (variant) {
      case BarrierVariant.LOW:
        return 1
      case BarrierVariant.HIGH:
        return 1
      case BarrierVariant.DOUBLE:
        return 2
      default:
        return 1
    }
  }

  /**
   * 根据变体获取分数值
   * @param variant - 栅栏变体
   * @returns 分数值
   */
  private static getScoreByVariant(variant: BarrierVariant): number {
    switch (variant) {
      case BarrierVariant.LOW:
        return 10
      case BarrierVariant.HIGH:
        return 15
      case BarrierVariant.DOUBLE:
        return 25
      default:
        return 15
    }
  }

  /**
   * 更新栅栏障碍物逻辑
   * @param deltaTime - 时间差
   */
  protected updateObstacle(deltaTime: number): void {
    // 更新动画时间（用于视觉效果）
    this.animationTime += deltaTime

    // 栅栏是静态的，只需要基本的位置更新
    // 可以添加轻微的摇摆效果
    if (this.variant === BarrierVariant.DOUBLE) {
      this.addSwayEffect()
    }
  }

  /**
   * 添加摇摆效果（双重栅栏）
   */
  private addSwayEffect(): void {
    // 这里可以调整渲染位置，但不改变碰撞检测位置
    // 实际实现时可以通过修改sprite的渲染偏移来实现
    // const swayAmount = Math.sin(this.animationTime * 0.002) * 2
  }

  /**
   * 渲染栅栏障碍物
   * @param ctx - Canvas渲染上下文
   */
  render(ctx: CanvasRenderingContext2D): void {
    if (!this.visible) return

    if (this.sprite && this.sprite.image) {
      super.render(ctx)
    } else {
      this.renderDefault(ctx)
    }

    // 添加变体特定的视觉效果
    this.renderVariantEffects(ctx)
  }

  /**
   * 渲染默认外观
   * @param ctx - Canvas渲染上下文
   */
  protected renderDefault(ctx: CanvasRenderingContext2D): void {
    const color = this.getVariantColor()
    
    switch (this.variant) {
      case BarrierVariant.LOW:
        this.renderLowBarrier(ctx, color)
        break
      case BarrierVariant.HIGH:
        this.renderHighBarrier(ctx, color)
        break
      case BarrierVariant.DOUBLE:
        this.renderDoubleBarrier(ctx, color)
        break
    }
  }

  /**
   * 渲染低栅栏
   * @param ctx - Canvas渲染上下文
   * @param color - 颜色
   */
  private renderLowBarrier(ctx: CanvasRenderingContext2D, color: string): void {
    ctx.fillStyle = color
    ctx.fillRect(this.x, this.y, this.width, this.height)
    
    // 添加栅栏纹理
    ctx.strokeStyle = '#654321'
    ctx.lineWidth = 2
    for (let i = 0; i < 3; i++) {
      const lineY = this.y + (this.height / 4) * (i + 1)
      ctx.beginPath()
      ctx.moveTo(this.x, lineY)
      ctx.lineTo(this.x + this.width, lineY)
      ctx.stroke()
    }
  }

  /**
   * 渲染高栅栏
   * @param ctx - Canvas渲染上下文
   * @param color - 颜色
   */
  private renderHighBarrier(ctx: CanvasRenderingContext2D, color: string): void {
    ctx.fillStyle = color
    ctx.fillRect(this.x, this.y, this.width, this.height)
    
    // 添加栅栏纹理
    ctx.strokeStyle = '#654321'
    ctx.lineWidth = 2
    for (let i = 0; i < 5; i++) {
      const lineY = this.y + (this.height / 6) * (i + 1)
      ctx.beginPath()
      ctx.moveTo(this.x, lineY)
      ctx.lineTo(this.x + this.width, lineY)
      ctx.stroke()
    }
    
    // 添加顶部尖刺
    ctx.fillStyle = '#444444'
    for (let i = 0; i < this.width; i += 8) {
      ctx.fillRect(this.x + i, this.y - 5, 4, 5)
    }
  }

  /**
   * 渲染双重栅栏
   * @param ctx - Canvas渲染上下文
   * @param color - 颜色
   */
  private renderDoubleBarrier(ctx: CanvasRenderingContext2D, color: string): void {
    const halfHeight = this.height / 2
    
    // 渲染下半部分
    ctx.fillStyle = color
    ctx.fillRect(this.x, this.y + halfHeight, this.width, halfHeight)
    
    // 渲染上半部分（稍微偏移）
    const swayOffset = Math.sin(this.animationTime * 0.002) * 2
    ctx.fillRect(this.x + swayOffset, this.y, this.width, halfHeight - 10)
    
    // 添加连接部分
    ctx.strokeStyle = '#654321'
    ctx.lineWidth = 3
    ctx.beginPath()
    ctx.moveTo(this.x + this.width / 2, this.y + halfHeight - 10)
    ctx.lineTo(this.x + this.width / 2 + swayOffset, this.y + halfHeight)
    ctx.stroke()
  }

  /**
   * 渲染变体特效
   * @param ctx - Canvas渲染上下文
   */
  private renderVariantEffects(ctx: CanvasRenderingContext2D): void {
    if (this.variant === BarrierVariant.DOUBLE) {
      // 添加危险警告效果
      const alpha = (Math.sin(this.animationTime * 0.01) + 1) / 2 * 0.3
      ctx.fillStyle = `rgba(255, 0, 0, ${alpha})`
      ctx.fillRect(this.x - 5, this.y - 5, this.width + 10, this.height + 10)
    }
  }

  /**
   * 获取变体颜色
   * @returns 颜色字符串
   */
  private getVariantColor(): string {
    switch (this.variant) {
      case BarrierVariant.LOW:
        return '#8B4513' // 棕色
      case BarrierVariant.HIGH:
        return '#A0522D' // 深棕色
      case BarrierVariant.DOUBLE:
        return '#CD853F' // 金棕色
      default:
        return '#8B4513'
    }
  }

  /**
   * 检查玩家是否可以通过滑铲避开
   * @returns 是否可以滑铲通过
   */
  canSlideUnder(): boolean {
    return this.variant === BarrierVariant.LOW
  }

  /**
   * 检查玩家是否需要跳跃避开
   * @returns 是否需要跳跃
   */
  requiresJump(): boolean {
    return this.variant === BarrierVariant.HIGH || this.variant === BarrierVariant.DOUBLE
  }

  /**
   * 获取障碍物描述
   * @returns 描述信息
   */
  getDescription(): string {
    const baseDesc = super.getDescription()
    const actionHint = this.canSlideUnder() ? '(可滑铲通过)' : 
                      this.requiresJump() ? '(需跳跃通过)' : ''
    return `${baseDesc} - ${this.variant}栅栏 ${actionHint}`
  }
}